Software architectures: multi-scale refinement

We propose a multi-scale modeling approach for complex software system architecture description. The multi-scale description may help to obtain meaningful granularities of these systems and to understand and master their complexity. This vision enables an architect designer to express constraints concerning different description levels, oriented to facilitate adaptability management. We define a correct-by-design approach that allows a given abstract architectural description to be refined into architecture models. We follow a progressive refinement process based on model transformations; it begins with a coarse-grain description and ends with a fine-grain description that specifies design details. The adaptability property management is performed through model transformation operations. The model transformation ensures the correctness of UML description, and the correctness of the modeled system. We experimented our approach with a use case that models a smart home system for the monitoring of elderly and disabled persons at home

A Graph Transformation-Based Approach for the Validation of Checkpointing Algorithms in Distributed Systems

International audience—Autonomic Computing Systems are oriented to pre-vente the human intervention and to enable distributed systems to manage themselves. One of their challenges is the efficient monitoring at runtime oriented to collect information from which the system can automatically repair itself in case of failure. Quasi-Synchronous Checkpointing is a well-known technique, which allows processes to recover in spite of failures. Based on this technique, several checkpointing algorithms have been developed. According to the checkpoint properties detected and ensured, they are classified into: Strictly Z-Path Free (SZPF), Z-Path Free (ZPF) and Z-Cycle Free (ZCF). In the literature, the simulation has been the method adopted for the performance evaluation of checkpointing algorithms. However, few works have been designed to validate their correctness. In this paper, we propose a validation approach based on graph transformation oriented to automatically detect the previous mentioned checkpointing properties. To achieve this, we take the vector clocks resulting from the algorithm execution, and we model it into a causal graph. Then, we design and use transformation rules oriented to verify if in such a causal graph, the algorithm is exempt from non desirable patterns, such as Z-paths or Z-cycles, according to the case

An Operational Semantics Dedicated to the Coordination of Cooperating Agents

Abstract. This paper presents a contribution towards rigourous reasoning about coordinating agents. First, it defines formal models for coordination and coordinating agents. These models enable to specify the relations between the concepts of: plan, plan proposal and resource allocation, on the one hand, and concepts of: knowledge, belief and capability, on the other hand. Second, it provides a structured coordination language enabling to specify primitives, protocols and processes of coordination. This language is defined by a precise syntax, and it is formally interpreted using a transition system leading to an operational semantics for coordinating agents

A Pattern based Modelling for Self-Organizing Multi-Agent Systems with Event-B

International audienceSelf-Organizing Multi-Agent Systems (SO-MAS) are defined as a set of autonomous entities called agents interacting together in order to achieve a given task. Generally, the development process of these systems is based on the bottom-up approach which focuses on the design of the entities individual behavior. The main question arising when developing SO-MAS is how to insure that the designed entities, when interacting together, will give rise to the desired behavior? Our proposition to deal with this question is to use formal methods. We propose a correct by construction method for systematic design of SO-MAS based on the use of design patterns and formal stepwise refinements. Our work gives guidelines to assist the designer when developing the individual behavior of the entities and prove its correctness at the early stages of the design process. The method is illustrated with the foraging ants’ case study

From Formal Specification to Model Checking of MAS Using CSP-Z and SPIN

Abstract. As a result of the increasingly predominance of agent technology, there has been a lot of interest in developing agent-based methodologies. In particular, formal methodologies have recently received the attention of the agent community. One of the key features of these methodologies is their emphasis on the use of formal methods as a means to trust multiagent systems (MAS) to behave as expected. The main purpose of this paper is to extend the development process of a formal approach for designing agent-based applications, called ForMAAD. The effort expended in the added phase is concentrated on two tasks: formally specify MAS to provide a more concrete specification, and verify that the specified system fulfils correctness properties. The adoption of formal techniques from the concurrency theory is founded on the view of MAS as a computational organization of concurrent problem-solving entities

A Formal Model of a Multi-step Coordination Protocol for Self-adaptive Software Using Coloured Petri Nets

International audienceTechnology advances continue to make computing environments ever changing and more complex. In the presence of such environments software systems are increasingly expected to continue operating at run-time. As human intervention becomes costly, time-consuming and error-prone, these systems should be equipped with self-adaptation capabilities in order to adapt themselves in response to environmental changes. While most of the research in this area focuses on individual parts of an adaptive system, our work leverages on this research but tackles the problem where interdependent and distributed adaptations are concurrently performed. In this paper, we approach behavioural changes of component-based systems in two stages. First, we propose a process to individually adapt one component at a time. Second, we elaborate a coordination protocol to maintain globally consistent state when implementing distributed adaptations. To achieve correct coordination, rather than only considering dependency relations between multiple adaptations, our approach further focuses on dependency relations between components at run-time. Motivated by the potential benefits of using formalisms, we construct a formal model of our protocol using Coloured Petri Nets in order for an adaptive system to be trusted after adaptation. In the model, we make sufficient abstraction of details, but still deal with the core of the protocol. This makes the model simpler and the analysis easier due to restricted state space size. We verify key behavioural properties and conduct CTL model checking to assess the correctness of the model and thereby the correctness of the protocol

Vérification des propriétés non-fonctionnelles pour l'orchestration de services web

La composition de services est une tâche primordiale dans le développement de systèmes orientés service. L'orchestration se présente comme un ensemble de mécanismes pour la composition d'un nouveau service web formé d'un ensemble de services atteignables. Afin de valider une telle composition, deux classes de propriétés non fonctionnelles doivent être prises en considération à savoir les propriétés génériques et les propriétés spécifiques. Les propriétés génériques peuvent être vérifiées pour tous les services web invoqués dans une orchestration. Les propriétés spécifiques constituent les relations d'interdépendance entre les différentes activités au sein d'un processus d'orchestration. Ces propriétés ne peuvent pas être vérifiées directement sur le processus, l'utilisation donc d'une technique formelle s'avère intéressante. Pour se faire, nous présenterons dans cet article notre approche formelle pour la validation d'une orchestration de services web. L'approche adopte BPEL 2.0 (Business Process Execution Language) comme langage d'orchestration de services web et utilise le model-checker SPIN pour la vérification. La spécification BPEL est traduite en code Promela, le langage de spécification de SPIN, afin de vérifier aussi bien les propriétés génériques que les propriétés spécifiques exprimées en LTL (Linear Temporal Logic). L'outil de transformation de BPEL en Promela est développé en utilisant ANTLR (ANother Tool for Language Recognition). Ce travail a été couronné par le développement de l'outil {\sc BpelVT} (BPEL Verification Tool) afin de consolider l'approche proposée

An Approach for Modeling and Formalizing SOA Design Patterns

11 pagesInternational audienceAlthough design patterns has become increasingly popular, most of them are presented in an informal way, which can give rise to ambiguity and may lead to their incorrect usage. Patterns proposed by the SOA design pattern community are described with informal visual notations. Modeling SOA design patterns with a standard formal notation contributes to avoid misunderstanding by software architects and helps endowing design methods with refinement approaches for mastering system architectures complexity. In this paper, we present a formal architecture-centric approach that aims, first, to model message-oriented SOA design patterns with the SoaML standard language, and second to formally specify these patterns at a high level of abstraction using the Event-B method. These two steps are performed before undertaking the effective coding of a design pattern providing correct by construction patternbased software architectures. Our approach is experimented through an example we present in this paper. We implemented our approach under the Rodin platform, which we use to prove model consistency

Towards an Approach for Modeling and Formalizing SOA Design Patterns with Event-B

International audienceThis paper introduces a formal architecture-centric approach, which allows first to model message-oriented SOA design patterns with the SoaML standard language, and second to formally specify these patterns at a high level of abstraction using the Event-B method. These two steps are performed before undertaking the effective coding of a design pattern providing correct by construction pattern-based software architectures. We implement our approach under the Rodin platform which we use to prove model consistency